/**
 * @date: 2019/8/13
 * @author 风信子
 * @Description: 工具类方法
 */

import { history } from 'umi';
import actions from '@/utils/globalStateActions';

/**
 * @date: 2019/8/13
 * @author 风信子
 * @Description: 跳转页面传参数
 * @method routerState
 * @param {string} 参数：url 参数描述：跳转的地址
 * @param {object} 参数：state 参数描述：跳转的参数
 * @param {string} 参数：keyName 参数描述：key 名称
 * @return {返回值类型} 返回值说明
 */

export const routerState = (
  url: string,
  state: {} = {},
  keyName: string = 'routerState',
) => {
  sessionStorage.setItem(keyName, JSON.stringify(state));
  history.push({
    pathname: url,
    state,
  });
};
/**
 * @date: 2019/8/13
 * @author 风信子
 * @Description: 获取路由参数  解决刷新页面后state丢失问题
 * @method getRouterState
 * @param {this} 参数：self 参数描述：页面的props
 * @return {any} 参数返回
 */
export function getRouterState(
  props: any,
  keyName: string = 'routerState',
): any {
  const {
    location: { state },
  } = props;
  // @ts-ignore
  return state || JSON.parse(sessionStorage.getItem(keyName));
}

/**
 * @date: 2019/11/14
 * @author 风信子
 * @Description: 处理表格下载字段数据
 * @method handleDownloadTableValue
 * @param {object[]} 参数：data 参数描述：表格数据
 * @param {} 参数：data 参数描述：字段顺序
 * @return {返回值类型} 返回值说明
 */
export function handleDownloadTableValue(
  data: any,
  fieldOrder: string[] = Object.keys(data[0]),
) {
  const table = data.map((item: { [x: string]: any }) => {
    const tableList = fieldOrder.map(itemList => item[itemList]);
    return tableList;
  });
  return table;
}

/**
 * @date: 2020/5/12
 * @author 风信子
 * @Description: 方法说明 处理表格数据 里边是对象的形式
 * @method 方法名 handleDownloadTableObjectValue
 * @param {object[]} 参数：data 参数描述：表格数据
 * @param {array} 参数：data 参数描述：字段顺序
 * @return {返回值类型} 返回值说明
 */
export function handleDownloadTableObjectValue(
  data: any,
  fieldOrder: string[] = Object.keys(data[0]),
) {
  const table = data.map((item: { [x: string]: { value: any } }) => {
    const tableList = fieldOrder.map(itemList => item[itemList].value);
    return tableList;
  });
  return table;
}

export function toFormData(params: any) {
  const formdata = new FormData();
  for (const key in params) {
    if (typeof params[key] !== 'undefined') {
      formdata.append(key, params[key]);
    }
  }
  return formdata;
}

/**
 * @date: 2020/8/07
 * @author Yzh
 * @Description: 方法说明 去除字符串开始与结束的空格，保留中间空格
 * @method 方法名 removeAllSpace
 * @param {string} 参数：str 参数描述：传入字符串
 * @return {返回值类型} 返回值说明
 */
export function removeStartAndEndSpace(str: string): string {
  return str.replace(/^\s*|\s*$/g, '');
}

//
/**
 * @date: 2020/8/19
 * @author 风信子
 * @Description: 方法说明 处理数据格式 去逗号
 * @method 方法名 formatData
 * @param {string} 参数名 data  参数说明 包含逗号的数据
 * @return {number | string } 返回值说明 去逗号之后的数据
 */
export function formatData(
  data: string,
  roToZero: boolean = false,
): number | string {
  if (roToZero && data === '-') {
    return 0;
  } else if (data !== '-') {
    return data.indexOf(',') === -1
      ? parseFloat(data)
      : parseFloat(data.replace(/,/g, ''));
  } else {
    return data;
  }
}

/**
 * @date: 2020/08/31
 * @author 喵帕斯
 * @Description: 配置不同分辨率下input宽度
 * @method getInputWidth
 * @return {返回值类型} 返回值说明
 */
export const getInputWidth = () => {
  const screenWidth = window.screen.width;
  const configWidthArray = ['120px', '150px', '200px'];
  let width = configWidthArray[0];
  if (screenWidth <= 1300) {
    width = configWidthArray[0];
  } else if (1300 < screenWidth && screenWidth < 1800) {
    width = configWidthArray[1];
  } else if (screenWidth >= 1800) {
    width = configWidthArray[2];
  }
  return width;
};

/**
 * @date: 2020/9/17
 * @author 风信子
 * @Description: 方法说明 获取菜单信息
 * @method 方法名 getMarkInfo
 * @param {参数类型} 参数名 参数说明
 * @return {返回值类型} 返回值说明
 */
export function getMarkInfo() {
  // @ts-ignore
  const globalState = actions.getGlobalState();
  const originUrl = window.location.pathname;
  if (globalState.url && originUrl === globalState.url) {
    const { markType, name, url, dateType } = globalState;
    return {
      markType,
      name,
      url,
      dateType,
    };
  }
  return {};
}

/**
 * @date: 2020/9/29
 * @author 风信子
 * @Description: 方法说明  获取字符串字节长度
 * @method 方法名 getStrLength
 * @param {参数类型} 参数名 str 参数说明 目标字符串
 * @param {参数类型} 参数名 str 参数说明 字节长度
 * @return {返回值类型} 返回值说明
 */
export function getStrSubstring(str: string, size: number) {
  const _str = str.replace(/[\u4e00-\u9fa5]/g, 'aa');
  if (_str.length > size) {
    const oneSize = _str.substring(0, size).replace(/aa/g, '').length;
    const twoSize = (size - oneSize) / 2 + oneSize;
    return str.substring(0, twoSize) + '...';
  }`


  `
  return str;
}


/**
 * @date: 2020/12/18
 * @author 风信子
 * @Description: 方法说明 获取url 参数  如果不传或者是all  这返回所有
 * @method 方法名 getQueryVariable
 * @param {参数类型} 参数名 参数说明
 * @return {返回值类型} 返回值说明
 */
export function getQueryStringData(name:string = 'all') {
  const queryString = window.location.search.substring(1);
  if (queryString !== '') {
    const objAll:{[key:string]:string} = {};
    const vars = queryString.split('&');
    for (let i = 0; i < vars.length; i++) {
      const pair = vars[i].split('=');
      if (name === 'all') {
        objAll[pair[0]] = pair[1];
      } else if (pair[0] === name) {
        return pair[1];
      }
    }
    return Object.keys(objAll).length === 0 ? "" : objAll;
  }
  return '';
}


// 判断浏览器
export function iEVersion() {
  const { userAgent } = navigator; // 取得浏览器的userAgent字符串
  const isIE =
    userAgent.indexOf('compatible') > -1 && userAgent.indexOf('MSIE') > -1; // 判断是否IE<11浏览器
  const isEdge = userAgent.indexOf('Edge') > -1 && !isIE; // 判断是否IE的Edge浏览器
  const isIE11 =
    userAgent.indexOf('Trident') > -1 && userAgent.indexOf('rv:11.0') > -1;
  if (isIE) {
    const reIE = new RegExp('MSIE (\\d+\\.\\d+);');
    reIE.test(userAgent);
    const fIEVersion = parseFloat(RegExp.$1);
    if (fIEVersion === 7) {
      return 7;
    }
    if (fIEVersion === 8) {
      return 8;
    }
    if (fIEVersion === 9) {
      return 9;
    }
    if (fIEVersion === 10) {
      return 10;
    }
    return 6; // IE版本<=7
  }
  if (isEdge) {
    return 'edge'; // edge
  }
  if (isIE11) {
    return 11; // IE11
  }
  return -1; // 不是ie浏览器
}

/**
 * @date: 2021/6/7
 * @author 风信子
 * @Description: 方法说明 判断数据类型
 * @method 方法名 getType
 * @return {返回值类型} 返回值说明  string  number object  array null  等 都是小写字母
 * @param obj
 */
export function getType(obj:any) {
  const type:string = typeof obj;
  if (type !== 'object') {
    return type;
  }
  return Object.prototype.toString.call(obj).replace(/^\[object (\S+)\]$/, '$1').toLowerCase();
}

/**
 * @date: 2021/6/7
 * @author 风信子
 * @Description: 方法说明 antd 表格数据转换成下载需要的数据格式
 * @method 方法名 handleDownloadTableData
 * @param {Array} 参数名 thData 参数说明 表头数据
 * @param {Array} 参数名 tbodyData 参数说明 表体数据
 * @param {string} 参数名 nameKey 参数说明 表头名称字段的key 默认是 name | title 否则自己传
 * @param {string} 参数名 idKey 参数说明 表头对应数据的key数据 默认 dataIndex | id 否则自己传
 * @param {string} 参数名 key 参数说明 表体数据如果是对象 默认取 value 否则自己传
 * @return {返回值类型} 返回值说明
 */
export function handleDownloadTableData(
  thData = [],
  tbodyData = [],
  nameKey = 'title',
  idKey = 'dataIndex',
  key = 'value',
  removeField:[]
) {
  const downloadTbodyKey: any = []; // 处理出key
  // 处理表头名称
  const tableTitle: any  = [];
    thData.forEach((item) => {
      // @ts-ignore
      const id = item?.[idKey] ?? item?.id ?? ''
    if(!removeField.includes(id)){
      // @ts-ignore
      downloadTbodyKey.push(id);
      // @ts-ignore
      tableTitle.push(item?.[nameKey] ?? item?.name ?? '');
    }

  });
  // 根据downloadTbodyKey 处理数据格式
  const tableValue = tbodyData.map((item) => {
    const tableList = downloadTbodyKey.map((itemList: any) => {
      if (getType(item[itemList]) === 'string') {
        return item[itemList];
      } else if (getType(item[itemList]) === 'object') {
        // @ts-ignore
        if(getType(item[itemList]?.value) === 'array'){
          // @ts-ignore
          return item[itemList]?.value.join(';');
        } else{
          // @ts-ignore
          return item[itemList]?.[key] ?? item[itemList]?.value;
        }
      }
      return '';
    });
    return tableList;
  });
  return {
    title: [tableTitle],
    value: tableValue,
  };
}


export function getCookie(key: string) {
  let arr: any,
    reg = new RegExp('(^| )' + key + '=([^;]*)(;|$)');
  if (window.document.cookie.match(reg)) {
    arr = window.document.cookie.match(reg);
    return arr[2];
  } else {
    // router.push({
    //   pathname:"/login",
    // })
    return '';
    // return {key:null}; // 防止没有key 的时候报错
  }
}
